home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 10 / FM Towns Free Software Collection 10.iso / ms_dos / tool / ivscr / ivscr.c next >
Text File  |  1995-02-09  |  8KB  |  408 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <dos.h>
  4.  
  5. #define ImageWidth        0x100
  6. #define ImageLength        0x101
  7. #define BitsPerSample    0x102
  8.  
  9. #define    PATHDIV    ('\\')
  10. #define    PATHDIVSTR    "\\"
  11. #define    ERR        1
  12. #define    NOERR    0
  13.  
  14. typedef struct
  15. {
  16.     unsigned short int    tag;
  17.     unsigned short int    type;
  18.     unsigned long int    length;
  19.     unsigned long int    value;
  20.  
  21. } TAG;
  22.  
  23. char    *colsort[6] = { "  2", " 16", "256", "32k", "ful", "---" };
  24.  
  25. int        IVscradd( const char *, int );
  26. int        IVscrcreate();
  27. int        getTIFFinformation( const char *, int *, int *, int * );
  28. int        analyzeFilename( const char *, char *, char *, char *, char * );
  29. int        value( const char * );
  30.  
  31. /*
  32.     オプションリファレンス
  33.  
  34.     -d    下位ディレクトリ検索の抑制
  35.     -i    インターバルタイムの設定
  36.     -p    検索パスの設定
  37.     -f    ファイル情報の非表示
  38.     -v    最大ファイル数
  39. */
  40. char    cdir[128],path[128],ivfile[128],drive[4],dir[128],name[16],kaku[4],num[4];
  41. char    interval[4];
  42. int        flag = 0;
  43. int        maxfile = 64;
  44. int        total = 0;
  45.  
  46. void    main( int argc, char *argv[] )
  47. {
  48.     int        i;
  49.     int        ao = 1;
  50.  
  51.     if( argc < 2 )
  52.     {
  53.         printf( "[IV SCRIPT MAKER]  By SAKU\nusage: >ivscr [-option] [filename for output]\n\n-d\t下位ディレクトリ検索の抑制\n-i\tインターバルタイムの設定\n-p\t検索パスの設定\n-f\tファイル情報の非表示\n-v\t一つのIVファイルに対する最大ファイル数\n" );
  54.         return;
  55.     }
  56.  
  57.     getcwd( cdir, 128 );
  58.     strcat( path, cdir );
  59.     if( path[3] )
  60.         path[2] = 0;
  61.     strcpy( num, "00" );
  62.  
  63.     while( *argv[ao] == '-' || *argv[ao] == '/' )
  64.     {
  65.         switch( *(argv[ao]+1) )
  66.         {
  67.             case 'p':
  68.                 strcpy( path, argv[ao]+2 );
  69.                 break;
  70.             case 'i':
  71.                 strcpy( interval, argv[ao]+2 );
  72.                 break;
  73.             case 'd':
  74.                 flag |= 1;
  75.                 break;
  76.             case 'f':
  77.                 flag |= 2;
  78.                 break;
  79.             case 'v':
  80.                 i = value( argv[ao]+2 );
  81.                 if( i<1 || i>140 )
  82.                 {
  83.                     fprintf( stderr, "%s is bad value for '-v'.\n", argv[ao]+2 );
  84.                     return;
  85.                 }
  86.                 maxfile = i;
  87.                 break;
  88.         }
  89.         ++ ao;
  90.     }
  91.  
  92.     if( analyzeFilename( argv[ao], drive, dir, name, kaku ) )
  93.     {
  94.         fprintf( stderr, "%s is bad name.\n", argv[ao] );
  95.         return;
  96.     }
  97.  
  98.     if( IVscrcreate() )
  99.     {
  100.         fprintf( stderr, "%s cannot write.\n", ivfile );
  101.         return;
  102.     }
  103.  
  104.     if( IVscradd( path, flag ) )
  105.     {
  106.         printf( "Error happened.\n" );
  107.         return;
  108.     }
  109.  
  110.     printf( "normal end.\n" );
  111.     return;
  112. }
  113.  
  114. int        IVscrcreate()
  115. {
  116.     FILE    *fp;
  117.     static char num[4] = "00";
  118.  
  119.     strcpy( ivfile, drive );
  120.     strcat( ivfile, dir );
  121.     if( strlen( name ) > 6 )
  122.         name[6] = 0;
  123.     strcat( ivfile, name );
  124.     strcat( ivfile, num );
  125.     strcat( ivfile, "." );
  126.     if( *kaku == 0 )
  127.         strcat( kaku, "iv" );
  128.     strcat( ivfile, kaku );
  129.     ++ num[1];
  130.     if( num[1] > '9' )
  131.     {
  132.         ++ num[0];
  133.         num[1] = '0';
  134.     }
  135.  
  136.     if( ( fp = fopen( ivfile, "w" ) ) == NULL )
  137.         return ERR;
  138.  
  139.     fprintf( fp, "%s\n", "IV_SCRIPT(V1.0)" );
  140.     fprintf( fp, "interval %s\n", interval );
  141.  
  142.     fclose( fp );
  143.     return NOERR;
  144. }
  145.  
  146. int        IVscradd( const char *path, int f )
  147. {
  148.     FILE    *fp;
  149.     struct find_t    findbuf;
  150.     char    wild[128],tifname[128];
  151.     unsigned    ret;
  152.     int        col,dx,dy;
  153.     static int    num = 0;
  154.  
  155. /*    ファイル検索    */
  156.  
  157.     if( ( fp = fopen( ivfile, "a" ) ) == NULL )
  158.         return ERR;
  159.     fprintf( stdout, "%s\n", path );
  160.  
  161.     strcpy( wild, path );
  162.     strcat( wild, "\\*.TIF" );
  163.     if( _dos_findfirst( wild, _A_NORMAL, &findbuf ) == 0 )
  164.     {
  165.         ret = 0;
  166.         while( ret == 0 )
  167.         {
  168.             ++ num;
  169.             ++ total;
  170.             if( total > maxfile )
  171.             {
  172.                 total = 1;
  173.                 fclose( fp );
  174.                 if( IVscrcreate() )
  175.                     return ERR;
  176.                 if( ( fp = fopen( ivfile, "a" ) ) == NULL )
  177.                     return ERR;
  178.             }
  179.             fprintf( fp, "show    %s\\%s\n", path, findbuf.name );
  180.             if( (f & 2) == 0 )
  181.             {
  182.                 strcpy( tifname, path );
  183.                 strcat( tifname, "\\" );
  184.                 strcat( tifname, findbuf.name );
  185.                 if( getTIFFinformation( tifname, &col, &dx, &dy ) )
  186.                     fprintf( fp, "message <No %3d>                            %s\\%s\n", num, path, findbuf.name );
  187.                 else
  188.                     fprintf( fp, "message <No %3d> size( %3d * %3d ) sort[%s]%s\\%s\n", num, dx, dy, colsort[col], path, findbuf.name );
  189.             }
  190.             ret = _dos_findnext( &findbuf );
  191.         }
  192.     }
  193.     fclose( fp );
  194.     if( f & 1 )
  195.         return NOERR;
  196.  
  197. /*    ディレクトリ検索    */
  198.  
  199.     strcpy( wild, path );
  200.     strcat( wild, "\\*.*" );
  201.     if( _dos_findfirst( wild, _A_SUBDIR, &findbuf ) != 0 )
  202.     {
  203.         return NOERR;
  204.     }
  205.  
  206.     ret = 0;
  207.     while( ret == 0 )
  208.     {
  209.         if( findbuf.attrib & _A_SUBDIR )
  210.         {
  211.             if( findbuf.name[0] != '.' )
  212.             {
  213.                 strcpy( wild, path );
  214.                 strcat( wild, "\\" );
  215.                 strcat( wild, findbuf.name );
  216.                 if( IVscradd( wild, f ) )
  217.                     return ERR;
  218.             }
  219.         }
  220.         ret = _dos_findnext( &findbuf );
  221.     }
  222.  
  223.     return NOERR;
  224. }
  225.  
  226. int        getTIFFinformation( const char *name, int *col, int *dx, int *dy )
  227. {
  228.     FILE    *fp;
  229.     TAG        tg;
  230.     int        i,colorsort;
  231.     long    d,IDFofs;
  232.     unsigned short    tagnum,k;
  233.     unsigned short    width,length;
  234.  
  235.     if( ( fp = fopen( name, "rb" ) ) == NULL )
  236.         return 1;
  237.  
  238.     if( fread( &d, 4, 1, fp ) < 1 )    /*    ヘッダの読込(4byte)    */
  239.     {
  240.         fclose( fp );
  241.         return 1;
  242.     }
  243.  
  244.     if( d != 0x002a4949 )
  245.     {
  246.         fclose( fp );
  247.         return 1;
  248.     }
  249.  
  250.     fread( &IDFofs, 4, 1, fp );        /*    IDF オフセット 読込    */
  251.     if( fseek( fp, IDFofs, SEEK_SET ) != 0 )
  252.     {
  253.         fclose( fp );
  254.         return 1;
  255.     }
  256.  
  257.     fread( &k, 2, 1 ,fp );        /*    タグの個数 読込    */
  258.     tagnum = k;
  259.  
  260.     for( i=0; i<tagnum; i++ )
  261.     {
  262.         fread( &tg, 12, 1, fp );    /*    タグデータ読込    */
  263.  
  264.         switch( tg.tag )    /*    タグIDによって分岐    */
  265.         {
  266.             case ImageWidth:
  267.                 width = tg.value;
  268.                 break;
  269.  
  270.             case ImageLength:
  271.                 length = tg.value;
  272.                 break;
  273.  
  274.             case BitsPerSample:
  275.                 if( tg.length != 1 )
  276.                 {
  277.                     colorsort = 4;
  278.                     break;
  279.                 }
  280.                 switch( tg.value )
  281.                 {
  282.                     case 0x01:
  283.                         colorsort = 0;
  284.                         break;
  285.                     case 0x04:
  286.                         colorsort = 1;
  287.                         break;
  288.                     case 0x08:
  289.                         colorsort = 2;
  290.                         break;
  291.                     case 0x10:
  292.                         colorsort = 3;
  293.                         break;
  294.                     default:
  295.                         colorsort = 5;
  296.                         break;
  297.                 }
  298.                 break;
  299.             default:
  300.                 break;
  301.         }
  302.     }
  303.     fclose( fp );
  304.  
  305.     *col = colorsort;
  306.     *dx = width;
  307.     *dy = length;
  308.  
  309.     return 0;
  310. }
  311.  
  312. int        analyzeFilename( const char *path, char *drive, char *dir, char *name, char *kaku )
  313. {
  314.     int        i;
  315.     const char    *adst,*anad;
  316.  
  317.     *drive = *dir = *name = *kaku = 0;
  318.     anad = path;
  319.  
  320.     if( *(anad+1) == ':' )
  321.     {
  322.         strncpy( drive, anad, 2 );
  323.         *(drive+2) = 0;
  324.         anad += 2;
  325.     }
  326.  
  327.     if( *anad == PATHDIV )
  328.     {
  329.         strcat( dir, PATHDIVSTR );
  330.         ++ anad;
  331.     }
  332.  
  333.     while(1)
  334.     {
  335.         adst = anad;
  336.         if( *anad == PATHDIV )    /*  "\"が続くのはダメ  */
  337.             return 1/*ERR*/;
  338. /*  ファイル名サーチ  */
  339.         i = 0;
  340.         while( *anad != 0 )
  341.         {
  342.             if( *anad == PATHDIV || *anad == '.' )
  343.                 break;
  344.             if( i>7 )    /*  名前が８文字を越えたらダメ  */
  345.                 return 2/*ERR*/;
  346.             ++ i;
  347.             ++ anad;
  348.         }
  349.         if( *anad == 0 )
  350.         {
  351.             if( i == 0 )
  352.                 return 3/*ERR*/;
  353.             strcpy( name, adst );
  354.             return NOERR;
  355.         }
  356.         if( *anad == PATHDIV )
  357.         {
  358.             strncat( dir, adst, i );
  359.             strcat( dir, PATHDIVSTR );
  360.             ++ anad;
  361.             continue;
  362.         }
  363. /*  拡張子サーチ  */
  364.         ++ anad;
  365.         i = 0;
  366.         while( *anad != 0 )
  367.         {
  368.             if( *anad == PATHDIV )
  369.                 break;
  370.             if( i>2 )    /*  拡張子が３文字を越えたらダメ  */
  371.                 return 4/*ERR*/;
  372.             ++ i;
  373.             ++ anad;
  374.         }
  375.         if( *anad == 0 )
  376.         {
  377.             strncpy( name, adst, (int)(anad-adst)-(i+1) );
  378.             strcpy( kaku, anad-i );
  379.             return NOERR;
  380.         }
  381.         if( *anad == PATHDIV )
  382.         {
  383.             strncat( dir, adst, anad-adst );
  384.             strcat( dir, PATHDIVSTR );
  385.             ++ anad;
  386.             continue;
  387.         }
  388.     }
  389.  
  390.     return NOERR;
  391. }
  392.  
  393. int        value( const char *s )
  394. {
  395.     int        i = 0;
  396.  
  397.     while( *s )
  398.     {
  399.         if( *s < '0' || *s > '9' )
  400.             return -1;
  401.         i *= 10;
  402.         i += *s - '0';
  403.         ++ s;
  404.     }
  405.  
  406.     return i;
  407. }
  408.